#include "qsql_duckdb.h"
#include "qsql_duckdb_p.h"
#include <QtSql/qsqlquery.h>
#include <QtSql/qsqlrecord.h>
#include <QtSql/qsqlerror.h>
#include <QtSql/qsqlfield.h>
#include <QtSql/qsqlindex.h>
#include <QtCore/qvariant.h>
#include <QtCore/qdatetime.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qvector.h>
#include <QtCore/qdebug.h>
#include <QMutexLocker>

QT_BEGIN_NAMESPACE

// ========== QDuckdbDatabaseManager 实现 ==========

/**
 * @brief 获取数据库管理器的单例实例
 * @return 数据库管理器实例指针
 */
QDuckdbDatabaseManager* QDuckdbDatabaseManager::instance()
{
    static QDuckdbDatabaseManager manager;
    return &manager;
}

/**
 * @brief 析构函数，清理所有数据库实例
 */
QDuckdbDatabaseManager::~QDuckdbDatabaseManager()
{
    QMutexLocker locker(&m_mutex);
    for (auto it = m_databases.begin(); it != m_databases.end(); ++it) {
        DatabaseInstance* instance = it.value();
        if (instance->refCount > 0) {
            // 数据库实例仍有引用但正在清理，这可能表示程序退出时的正常情况
        }
        duckdb_close(&instance->db);
        delete instance;
    }
    m_databases.clear();
}

/**
 * @brief 生成数据库实例的唯一键
 * @param dbPath 数据库文件路径
 * @param readOnly 是否为只读模式
 * @return 唯一键字符串
 */
QString QDuckdbDatabaseManager::makeKey(const QString& dbPath, bool readOnly)
{
    return dbPath + QStringLiteral("_") + (readOnly ? QStringLiteral("RO") : QStringLiteral("RW"));
}

/**
 * @brief 获取数据库实例，支持实例复用
 * @param dbPath 数据库文件路径
 * @param readOnly 是否为只读模式
 * @param config DuckDB配置对象
 * @param errorMsg 错误信息输出参数
 * @return 数据库实例句柄，失败时返回nullptr
 */
duckdb_database QDuckdbDatabaseManager::getDatabaseInstance(const QString& dbPath, bool readOnly, duckdb_config config, QString& errorMsg)
{
    QMutexLocker locker(&m_mutex);
    
    QString key = makeKey(dbPath, readOnly);
    DatabaseInstance* instance = m_databases.value(key, nullptr);
    
    if (instance) {
        // 复用现有实例
        instance->refCount++;
        return instance->db;
    }
    
    // 创建新实例
    instance = new DatabaseInstance();
    instance->dbPath = dbPath;
    instance->isReadOnly = readOnly;
    
    char* out_error = nullptr;
    duckdb_state status = duckdb_open_ext(dbPath.toUtf8().constData(), &instance->db, config, &out_error);
    
    if (status != DuckDBSuccess) {
        errorMsg = QString::fromUtf8(out_error);
        delete instance;
        return nullptr;
    }
    
    instance->refCount = 1;
    m_databases.insert(key, instance);
    
    return instance->db;
}

/**
 * @brief 释放数据库实例引用
 * @param dbPath 数据库文件路径
 * @param readOnly 是否为只读模式
 */
void QDuckdbDatabaseManager::releaseDatabaseInstance(const QString& dbPath, bool readOnly)
{
    QMutexLocker locker(&m_mutex);
    
    QString key = makeKey(dbPath, readOnly);
    DatabaseInstance* instance = m_databases.value(key, nullptr);
    
    if (!instance) {
        // 尝试释放不存在的数据库实例，可能是重复释放
        return;
    }
    
    instance->refCount--;
    
    if (instance->refCount <= 0) {
        // 没有更多引用，关闭数据库
        duckdb_close(&instance->db);
        m_databases.remove(key);
        delete instance;
    }
}

// ========== QDuckdbDriver 实现 ==========

/**
 * @brief 构造函数
 * @param parent 父对象指针
 */
QDuckdbDriver::QDuckdbDriver(QObject *parent)
    : QSqlDriver(*new QDuckdbDriverPrivate(), parent)
{
}

/**
 * @brief 析构函数
 */
QDuckdbDriver::~QDuckdbDriver()
{
    close();
}

/**
 * @brief 检查驱动是否支持指定特性
 * @param f 要检查的驱动特性
 * @return 如果支持返回true，否则返回false
 */
bool QDuckdbDriver::hasFeature(DriverFeature f) const
{
    switch (f) {
    case Transactions:
    case QuerySize:
    case BLOB:
    case Unicode:
    case PreparedQueries:
    case PositionalPlaceholders:
    case LastInsertId:
    case MultipleResultSets:
        return true;
    default:
        return false;
    }
}

/**
 * @brief 打开数据库连接
 * @param db 数据库路径，空字符串表示内存数据库
 * @param user 用户名（DuckDB不使用）
 * @param password 密码（DuckDB不使用）
 * @param host 主机名（DuckDB不使用）
 * @param port 端口号（DuckDB不使用）
 * @param connOpts 连接选项，支持readonly=true/false和threads=数字
 * @return 成功返回true，失败返回false
 */
bool QDuckdbDriver::open(const QString &db, const QString &user, const QString &password,
                         const QString &host, int port, const QString &connOpts)
{
    Q_D(QDuckdbDriver);
    Q_UNUSED(user);
    Q_UNUSED(password);
    Q_UNUSED(host);
    Q_UNUSED(port);
    cleanup();

    // DuckDB可以是内存数据库（空路径）或文件数据库
    QByteArray dbPathArray;
    const char *dbPath;
    if (db.isEmpty()) {
        dbPath = ":memory:";
    } else {
        dbPathArray = db.toUtf8();
        dbPath = dbPathArray.constData();
    }
    
    // 使用DuckDB原生API连接数据库
    duckdb_config config = nullptr;
    duckdb_create_config(&config);
    
    // 解析连接选项
    bool readOnly = false;
    int threadCount = 4; // 默认线程数
    
    QStringList opts = connOpts.split(QLatin1Char(';'), Qt::SkipEmptyParts);
    for (const QString &opt : opts) {
        QStringList pair = opt.split(QLatin1Char('='));
        if (pair.size() == 2) {
            QString key = pair.at(0).trimmed().toLower();
            QString value = pair.at(1).trimmed();
            
            if (key == QStringLiteral("readonly") && (value.toLower() == QStringLiteral("true") || value == QStringLiteral("1"))) {
                readOnly = true;
            } else if (key == QStringLiteral("threads") && !value.isEmpty()) {
                bool ok;
                int threads = value.toInt(&ok);
                if (ok && threads > 0) {
                    threadCount = threads;
                }
            }
        }
    }
    
    // 设置访问模式
    if (readOnly || connOpts.contains(QLatin1String("READ_ONLY"))) {
        duckdb_set_config(config, "access_mode", "READ_ONLY");
        d->isReadOnly = true;
    } else {
        duckdb_set_config(config, "access_mode", "READ_WRITE");
        d->isReadOnly = false;
    }
    
    // 设置多线程支持 - 优化并发性能
    QString threadSetting = QString::number(threadCount);
    duckdb_set_config(config, "threads", threadSetting.toUtf8().constData());
    
    // 使用数据库管理器获取共享实例
    QString errorMsg;
    d->db = QDuckdbDatabaseManager::instance()->getDatabaseInstance(QString::fromUtf8(dbPath), readOnly, config, errorMsg);
    if (!d->db) {
        d->errorMessage = errorMsg;
        setLastError(QSqlError(QStringLiteral("Connection error"), d->errorMessage, QSqlError::ConnectionError));
        return false;
    }
    
    // 保存数据库路径和只读状态，用于后续释放
    d->dbPath = QString::fromUtf8(dbPath);
    
    // 创建连接
    duckdb_state status = duckdb_connect(d->db, &d->conn);
    if (status != DuckDBSuccess) {
        d->errorMessage = QStringLiteral("Failed to connect to DuckDB database");
        duckdb_close(&d->db);
        setLastError(QSqlError(QStringLiteral("Connection error"), d->errorMessage, QSqlError::ConnectionError));
        return false;
    }
    
    // 初始化事务状态
    d->inTransaction = false;
    
    setOpen(true);
    setOpenError(false);
    return true;
}

/**
 * @brief 关闭数据库连接
 */
void QDuckdbDriver::close()
{
    Q_D(QDuckdbDriver);
    
    cleanup();
}

/**
 * @brief 创建查询结果对象
 * @return QDuckdbResult实例指针
 */
QSqlResult *QDuckdbDriver::createResult() const
{
    return new QDuckdbResult(this);
}

/**
 * @brief 获取数据库中的表列表
 * @param type 表类型（表、视图或全部）
 * @return 表名列表
 */
QStringList QDuckdbDriver::tables(QSql::TableType type) const
{
    Q_D(const QDuckdbDriver);
    
    QStringList tables;

    if (!d->conn) {
        return tables;
    }

    QString queryStr;
    switch (type) {
    case QSql::Tables:
        queryStr = QStringLiteral("SELECT table_name FROM information_schema.tables WHERE table_schema = 'main' AND table_type = 'BASE TABLE'");
        break;
    case QSql::Views:
        queryStr = QStringLiteral("SELECT table_name FROM information_schema.tables WHERE table_schema = 'main' AND table_type = 'VIEW'");
        break;
    case QSql::AllTables:
        queryStr = QStringLiteral("SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'");
        break;
    default:
        return tables;
    }

    // 使用DuckDB原生API执行查询
    duckdb_result result;
    duckdb_state status = duckdb_query(d->conn, queryStr.toUtf8().constData(), &result);
    if (status != DuckDBSuccess) {
        const_cast<QDuckdbDriverPrivate*>(d)->errorMessage = QStringLiteral("Failed to execute query");
        return tables;
    }

    // 处理查询结果
    int64_t rowCount = duckdb_row_count(&result);
    int columnCount = duckdb_column_count(&result);
    
    if (columnCount >= 1) {
        for (int64_t i = 0; i < rowCount; ++i) {
            duckdb_string value = duckdb_value_string(&result, 0, i);
            tables.append(QString::fromUtf8(value.data, value.size));
            duckdb_free(value.data);
        }
    }

    duckdb_destroy_result(&result);
    return tables;
}

/**
 * @brief 获取指定表的记录结构
 * @param tablename 表名
 * @return 表的记录结构信息
 */
QSqlRecord QDuckdbDriver::record(const QString &tablename) const
{
    Q_D(const QDuckdbDriver);
    
    QSqlRecord record;

    if (!d->conn) {
        return record;
    }

    QString schema, table;
    const_cast<QDuckdbDriverPrivate*>(d)->splitSchemaTableName(tablename, schema, table);
    QString queryStr = QStringLiteral("SELECT * FROM %1.%2 LIMIT 0").arg(schema).arg(table);

    // 使用DuckDB原生API执行查询
    duckdb_result result;
    duckdb_state status = duckdb_query(d->conn, queryStr.toUtf8().constData(), &result);
    if (status != DuckDBSuccess) {
        const_cast<QDuckdbDriverPrivate*>(d)->errorMessage = QStringLiteral("Failed to execute query");
        return record;
    }
    
    // 根据查询结果构建QSqlRecord
    int columnCount = duckdb_column_count(&result);
    
    for (int i = 0; i < columnCount; ++i) {
        const char* columnName = duckdb_column_name(&result, i);
        QString fieldName = QString::fromUtf8(columnName);
        
        // 获取列类型并映射到QVariant类型
        duckdb_type columnType = duckdb_column_type(&result, i);
        QMetaType::Type qtType = QMetaType::QString;
        
        switch (columnType) {
        case DUCKDB_TYPE_BOOLEAN:
            qtType = QMetaType::Bool;
            break;
        case DUCKDB_TYPE_TINYINT:
        case DUCKDB_TYPE_SMALLINT:
        case DUCKDB_TYPE_INTEGER:
            qtType = QMetaType::Int;
            break;
        case DUCKDB_TYPE_BIGINT:
            qtType = QMetaType::LongLong;
            break;
        case DUCKDB_TYPE_UTINYINT:
        case DUCKDB_TYPE_USMALLINT:
        case DUCKDB_TYPE_UINTEGER:
            qtType = QMetaType::UInt;
            break;
        case DUCKDB_TYPE_UBIGINT:
            qtType = QMetaType::ULongLong;
            break;
        case DUCKDB_TYPE_FLOAT:
        case DUCKDB_TYPE_DOUBLE:
            qtType = QMetaType::Double;
            break;
        case DUCKDB_TYPE_DATE:
            qtType = QMetaType::QDate;
            break;
        case DUCKDB_TYPE_TIMESTAMP:
            qtType = QMetaType::QDateTime;
            break;
        case DUCKDB_TYPE_VARCHAR:
            qtType = QMetaType::QString;
            break;
        case DUCKDB_TYPE_BLOB:
            qtType = QMetaType::QByteArray;
            break;
        default:
            qtType = QMetaType::QString;
            break;
        }
        
        QSqlField field(fieldName, QMetaType(qtType));
        record.append(field);
    }
    
    duckdb_destroy_result(&result);
    
    return record;
}

/**
 * @brief 获取指定表的主键索引
 * @param tablename 表名
 * @return 主键索引信息
 */
QSqlIndex QDuckdbDriver::primaryIndex(const QString &tablename) const
{
    Q_D(const QDuckdbDriver);
    QSqlIndex index;

    if (!d->conn) {
        return index;
    }

    QString schema, table;
    const_cast<QDuckdbDriverPrivate*>(d)->splitSchemaTableName(tablename, schema, table);
    QString queryStr = QStringLiteral("PRAGMA table_info('%1.%2')").arg(schema).arg(table);

    // 使用DuckDB原生API执行查询
    duckdb_result result;
    duckdb_state status = duckdb_query(d->conn, queryStr.toUtf8().constData(), &result);
    if (status != DuckDBSuccess) {
        const_cast<QDuckdbDriverPrivate*>(d)->errorMessage = QStringLiteral("Failed to execute query");
        return index;
    }
    
    // 处理查询结果 - DuckDB的PRAGMA table_info返回以下列：
    // cid, name, type, notnull, dflt_value, pk
    int64_t rowCount = duckdb_row_count(&result);
    int columnCount = duckdb_column_count(&result);
    
    if (columnCount >= 6) { // 确保有足够的列
        for (int64_t i = 0; i < rowCount; ++i) {
            // 检查第6列（pk）是否为1（表示主键）
            int32_t isPk = duckdb_value_int32(&result, 5, i);
            if (isPk == 1) {
                // 获取第2列（name）的列名
                duckdb_string colName = duckdb_value_string(&result, 1, i);
                QSqlField field(QString::fromUtf8(colName.data, colName.size));
                index.append(field);
                duckdb_free(colName.data);
            }
        }
    }
    
    duckdb_destroy_result(&result);
    
    index.setName(tablename);
    return index;
}

/**
 * @brief 获取底层数据库连接句柄
 * @return 数据库连接句柄的QVariant包装
 */
QVariant QDuckdbDriver::handle() const
{
    Q_D(const QDuckdbDriver);
    return QVariant::fromValue<void*>(reinterpret_cast<void*>(d->conn));
}

/**
 * @brief 格式化字段值为SQL字符串
 * @param field 要格式化的字段
 * @param trimStrings 是否修剪字符串
 * @return 格式化后的SQL字符串
 */
QString QDuckdbDriver::formatValue(const QSqlField &field, bool trimStrings) const
{
    if (field.isNull()) {
        return QStringLiteral("NULL");
    }

    switch (field.metaType().id()) {
    case QVariant::Bool:
        return field.value().toBool() ? QStringLiteral("TRUE") : QStringLiteral("FALSE");
    case QVariant::String:
    {
        QString str = field.value().toString();
        if (trimStrings) {
            str = str.trimmed();
        }
        // Escape single quotes
        str.replace(QLatin1Char('\''), QLatin1String("''"));
        return QStringLiteral("'%1'").arg(str);
    }
    case QVariant::ByteArray:
    {
        QByteArray data = field.value().toByteArray();
        QString hexString;
        for (int i = 0; i < data.size(); ++i) {
            hexString.append(QString::asprintf("%02x", static_cast<unsigned char>(data.at(i))));
        }
        return QStringLiteral("X'%1'").arg(hexString);
    }
    case QVariant::Date:
        return QStringLiteral("'%1'").arg(field.value().toDate().toString(QStringLiteral("yyyy-MM-dd")));
    case QVariant::DateTime:
        return QStringLiteral("'%1'").arg(field.value().toDateTime().toString(QStringLiteral("yyyy-MM-dd hh:mm:ss.zzz")));
    default:
        return QSqlDriver::formatValue(field, trimStrings);
    }
}

/**
 * @brief 转义SQL标识符
 * @param identifier 要转义的标识符
 * @param type 标识符类型
 * @return 转义后的标识符
 */
QString QDuckdbDriver::escapeIdentifier(const QString &identifier, IdentifierType type) const
{
    Q_UNUSED(type);
    
    // DuckDB uses double quotes for identifiers
    QString result = identifier;
    result.replace(QLatin1Char('"'), QLatin1String(""""));
    return QStringLiteral("""%1""").arg(result);
}

/**
 * @brief 检查标识符是否已被转义
 * @param identifier 要检查的标识符
 * @param type 标识符类型
 * @return 如果已转义返回true，否则返回false
 */
bool QDuckdbDriver::isIdentifierEscaped(const QString &identifier, IdentifierType type) const
{
    Q_UNUSED(type);
    // Check if the identifier is enclosed in double quotes
    return identifier.startsWith(QLatin1Char('"')) && identifier.endsWith(QLatin1Char('"'));
}

/**
 * @brief 开始数据库事务
 * @return 成功返回true，失败返回false
 */
bool QDuckdbDriver::beginTransaction()
{
    Q_D(QDuckdbDriver);
    
    if (!d->conn) {
        d->errorMessage = QStringLiteral("No active connection");
        setLastError(QSqlError(QStringLiteral("Connection error"), d->errorMessage, QSqlError::ConnectionError));
        return false;
    }
    
    // 检查是否已经在事务中
    if (d->inTransaction) {
        // 已经在事务中，直接返回成功
        return true;
    }

    // 使用DuckDB原生API执行BEGIN TRANSACTION语句
    duckdb_result result;
    duckdb_state status = duckdb_query(d->conn, "BEGIN TRANSACTION", &result);
    if (status != DuckDBSuccess) {
        d->errorMessage = QString::fromUtf8(duckdb_result_error(&result));
        setLastError(QSqlError(QStringLiteral("Transaction error"), d->errorMessage, QSqlError::TransactionError));
        duckdb_destroy_result(&result);
        return false;
    }
    
    // 设置事务状态
    d->inTransaction = true;
    
    duckdb_destroy_result(&result);
    return true;
}

/**
 * @brief 提交数据库事务
 * @return 成功返回true，失败返回false
 */
bool QDuckdbDriver::commitTransaction()
{
    Q_D(QDuckdbDriver);
    
    if (!d->conn) {
        d->errorMessage = QStringLiteral("No active connection");
        setLastError(QSqlError(QStringLiteral("Connection error"), d->errorMessage, QSqlError::ConnectionError));
        return false;
    }

    // 检查是否在事务中
    if (!d->inTransaction) {
        d->errorMessage = QStringLiteral("No transaction in progress");
        setLastError(QSqlError(QStringLiteral("Transaction error"), d->errorMessage, QSqlError::TransactionError));
        return false;
    }

    // 使用DuckDB原生API执行COMMIT语句
    duckdb_result result;
    duckdb_state status = duckdb_query(d->conn, "COMMIT", &result);
    if (status != DuckDBSuccess) {
        QString error = QString::fromUtf8(duckdb_result_error(&result));
        duckdb_destroy_result(&result);
        
        // 检查是否是并发冲突错误
        return handleConcurrencyConflict(error);
    }
    
    // 重置事务状态
    d->inTransaction = false;
    
    duckdb_destroy_result(&result);
    return true;
}

/**
 * @brief 回滚数据库事务
 * @return 成功返回true，失败返回false
 */
bool QDuckdbDriver::rollbackTransaction()
{
    Q_D(QDuckdbDriver);
    
    if (!d->conn) {
        d->errorMessage = QStringLiteral("No active connection");
        setLastError(QSqlError(QStringLiteral("Connection error"), d->errorMessage, QSqlError::ConnectionError));
        return false;
    }

    // 检查是否在事务中
    if (!d->inTransaction) {
        d->errorMessage = QStringLiteral("No transaction in progress");
        setLastError(QSqlError(QStringLiteral("Transaction error"), d->errorMessage, QSqlError::TransactionError));
        return false;
    }

    // 使用DuckDB原生API执行ROLLBACK语句
    duckdb_result result;
    duckdb_state status = duckdb_query(d->conn, "ROLLBACK", &result);
    if (status != DuckDBSuccess) {
        d->errorMessage = QString::fromUtf8(duckdb_result_error(&result));
        setLastError(QSqlError(QStringLiteral("Transaction error"), d->errorMessage, QSqlError::TransactionError));
        duckdb_destroy_result(&result);
        return false;
    }
    
    // 重置事务状态
    d->inTransaction = false;
    
    duckdb_destroy_result(&result);
    return true;
}

/**
 * @brief 清理数据库连接资源
 */
void QDuckdbDriver::cleanup()
{
    Q_D(QDuckdbDriver);

    if (d->conn) {
        duckdb_disconnect(&d->conn);
        d->conn = nullptr;
    }
    if (d->db) {
        // 使用数据库管理器释放实例，而不是直接关闭
        QDuckdbDatabaseManager::instance()->releaseDatabaseInstance(d->dbPath, d->isReadOnly);
        d->db = nullptr;
    }
    setOpen(false);
}

/**
 * @brief 获取最后一次错误的文本描述
 * @return 错误文本
 */
QString QDuckdbDriver::lastErrorText() const
{
    Q_D(const QDuckdbDriver);
    
    return d->errorMessage;
}

/**
 * @brief 处理DuckDB的乐观并发控制冲突
 * @param errorMsg DuckDB错误消息
 * @return 始终返回false
 */
bool QDuckdbDriver::handleConcurrencyConflict(const QString &errorMsg)
{
    Q_D(QDuckdbDriver);
    
    // 检查错误消息是否包含冲突相关的关键词
    if (errorMsg.contains(QStringLiteral("Conflict"), Qt::CaseInsensitive) || 
        errorMsg.contains(QStringLiteral("Transaction conflict"), Qt::CaseInsensitive) ||
        errorMsg.contains(QStringLiteral("Constraint violation"), Qt::CaseInsensitive)) {
        
        // 设置冲突错误
        d->errorMessage = QStringLiteral("Concurrent modification conflict: ") + errorMsg;
        setLastError(QSqlError(QStringLiteral("Concurrent modification conflict"), 
                              d->errorMessage, 
                              QSqlError::TransactionError));
    } else {
        // 设置一般事务错误
        d->errorMessage = QStringLiteral("Transaction error: ") + errorMsg;
        setLastError(QSqlError(QStringLiteral("Transaction error"), 
                              d->errorMessage, 
                              QSqlError::TransactionError));
    }
    
    // 重置事务状态
    d->inTransaction = false;
    
    return false;
}

// ========== QDuckdbResult 实现 ==========

/**
 * @brief 构造函数
 * @param db 数据库驱动指针
 */
QDuckdbResult::QDuckdbResult(const QDuckdbDriver *db)
    : QSqlResult(db)
{
    d_ptr = new QDuckdbResultPrivate(this, db);
    d_ptr->q_ptr = this;
}

/**
 * @brief 析构函数
 */
QDuckdbResult::~QDuckdbResult()
{
    Q_D(QDuckdbResult);
    d->cleanup();
}

/**
 * @brief 准备SQL查询语句
 * @param query SQL查询语句
 * @return 成功返回true，失败返回false
 */
bool QDuckdbResult::prepare(const QString &query)
{
    Q_D(QDuckdbResult);
    setQuery(query);
    return d->prepare(query);
}

/**
 * @brief 执行SQL查询语句
 * @return 成功返回true，失败返回false
 */
bool QDuckdbResult::exec()
{
    Q_D(QDuckdbResult);
    d->boundValues = boundValues();
    
    // 清除之前的结果
    setAt(QSql::BeforeFirstRow);
    setActive(false);
    
    // Bind values
    for (int i = 0; i < d->boundValues.size(); ++i) {
        if (!d->bindValue(i, d->boundValues[i])) {
            setLastError(QSqlError(QStringLiteral("Binding error"), d->lastError(), QSqlError::StatementError));
            return false;
        }
    }
    
    // 执行查询
    if (!d->execute()) {
        QString errorMsg = d->lastError();
        
        // 检查是否是并发冲突错误
        if (errorMsg.contains(QStringLiteral("Conflict"), Qt::CaseInsensitive) || 
            errorMsg.contains(QStringLiteral("Transaction"), Qt::CaseInsensitive)) {
            setLastError(QSqlError(QStringLiteral("Concurrent modification conflict"), 
                                  errorMsg, 
                                  QSqlError::TransactionError));
        } else {
            setLastError(QSqlError(QStringLiteral("Execution error"), 
                                  errorMsg, 
                                  QSqlError::StatementError));
        }
        return false;
    }

    // 设置查询类型和结果集信息
    bool isSelect = (duckdb_column_count(&d->result) > 0);
    setSelect(isSelect);
    setActive(true);
    setAt(isSelect ? QSql::BeforeFirstRow : QSql::AfterLastRow);
    
    // 设置行数和列数
    if (isSelect) {
        d->rowCount = duckdb_row_count(&d->result);
        d->affectedRows = 0;
    } else {
        // 非SELECT查询: 设置受影响的行数
        setActive(true);  // 非SELECT查询也应该设置为活动状态
        setAt(QSql::AfterLastRow);
        setSelect(false);
        d->affectedRows = duckdb_rows_changed(&d->result);
        if (d->affectedRows < 0) {
            d->affectedRows = 0;
        }
    }
    
    return true;
}

/**
 * @brief 获取最后插入记录的ID
 * @return 最后插入记录的ID，如果不支持则返回空值
 */
QVariant QDuckdbResult::lastInsertId() const
{
    // 简化实现，直接返回空值
    // 完整实现需要正确访问数据库连接
    return QVariant();
}

/**
 * @brief 获取底层查询句柄
 * @return 查询句柄的QVariant包装
 */
QVariant QDuckdbResult::handle() const
{
    Q_D(const QDuckdbResult);
    return QVariant::fromValue<void*>(static_cast<void*>(d->stmt));
}

/**
 * @brief 获取下一行数据
 * @return 成功返回true，失败或到达末尾返回false
 */
bool QDuckdbResult::fetchNext()
{
    Q_D(QDuckdbResult);
    
    if (!isActive() || !isSelect()) {
        return false;
    }

    // 检查结果集是否有效
    if (d->rowCount == -1) {
        setAt(QSql::AfterLastRow);
        return false;
    }

    // 检查结果集行数
    if (d->rowCount <= 0) {
        setAt(QSql::AfterLastRow);
        return false;
    }

    // 首次获取数据
    if (d->currentRow == -1) {
        d->currentRow = 0;
        setAt(d->currentRow);
        return true;
    }

    // 检查是否已到达结果集末尾
    if (d->currentRow >= d->rowCount - 1) {
        setAt(QSql::AfterLastRow);
        return false;
    }

    // 前进到下一行
    d->currentRow++;
    setAt(d->currentRow);
    
    // 验证当前行是否有效
    if (d->currentRow < 0 || d->currentRow >= d->rowCount) {
        setAt(QSql::AfterLastRow);
        return false;
    }

    return true;
}

/**
 * @brief 获取上一行数据
 * @return 成功返回true，失败或到达开头返回false
 */
bool QDuckdbResult::fetchPrev()
{
    Q_D(QDuckdbResult);
    if (d->currentRow <= 0) {
        setAt(QSql::BeforeFirstRow);
        return false;
    }
    d->currentRow--;
    setAt(d->currentRow);
    return true;
}

/**
 * @brief 获取第一行数据
 * @return 成功返回true，失败返回false
 */
bool QDuckdbResult::fetchFirst()
{
    Q_D(QDuckdbResult);
    
    if (!isActive() || !isSelect()) {
        return false;
    }

    // 检查结果集是否有效
    if (d->rowCount <= 0) {
        setAt(QSql::BeforeFirstRow);
        return false;
    }

    d->currentRow = 0;
    setAt(d->currentRow);
    return true;
}

/**
 * @brief 获取最后一行数据
 * @return 成功返回true，失败返回false
 */
bool QDuckdbResult::fetchLast()
{
    Q_D(QDuckdbResult);
    
    if (!isActive() || !isSelect()) {
        return false;
    }

    // 检查结果集是否有效
    if (d->rowCount <= 0) {
        setAt(QSql::BeforeFirstRow);
        return false;
    }

    d->currentRow = d->rowCount - 1;
    setAt(d->currentRow);
    return true;
}

/**
 * @brief 获取指定位置的数据行
 * @param i 行索引
 * @return 成功返回true，失败返回false
 */
bool QDuckdbResult::fetch(int i)
{
    Q_D(QDuckdbResult);
    if (i < 0) {
        setAt(QSql::BeforeFirstRow);
        return false;
    }
    
    // 对于未知行数的查询，直接返回false
    if (d->rowCount == -1) {
        setAt(QSql::BeforeFirstRow);
        return false;
    }
    
    // 对于已知行数的查询
    if (i >= d->rowCount) {
        setAt(QSql::AfterLastRow);
        return false;
    }
    
    d->currentRow = i;
    setAt(i);
    return true;
}

/**
 * @brief 重置查询结果并执行新查询
 * @param query 新的SQL查询语句
 * @return 成功返回true，失败返回false
 */
bool QDuckdbResult::reset(const QString &query)
{
    Q_D(QDuckdbResult);
    
    // 重置状态
    setActive(false);
    setAt(QSql::BeforeFirstRow);
    d->record.clear();
    d->boundValues.clear();
    
    // 清理现有资源
    d->cleanup();
    setQuery(query);
    
    // 准备查询
    if (!d->prepare(query)) {
        setLastError(QSqlError(QStringLiteral("Prepare error"), d->lastError(), QSqlError::StatementError));
        return false;
    }
    
    // 执行查询
    if (!d->execute()) {
        setLastError(QSqlError(QStringLiteral("Execution error"), d->lastError(), QSqlError::StatementError));
        return false;
    }

    // 处理结果
    bool isSelect = (duckdb_column_count(&d->result) > 0);
    setSelect(isSelect);
    setActive(isSelect);
    setAt(isSelect ? QSql::BeforeFirstRow : QSql::AfterLastRow);
    
    if (isSelect) {
        d->rowCount = duckdb_row_count(&d->result);
        d->affectedRows = 0;
        // 构建记录结构
        d->buildRecordFromResult();
    } else {
        d->affectedRows = duckdb_rows_changed(&d->result);
        d->rowCount = 0;
    }
    
    return true;
}

/**
 * @brief 获取指定字段的数据
 * @param field 字段索引
 * @return 字段数据
 */
QVariant QDuckdbResult::data(int field)
{
    Q_D(QDuckdbResult);
    if (field < 0 || field >= record().count())
        return QVariant();
    
    // 检查当前行是否有效
    if (at() < 0 || at() >= d->rowCount)
        return QVariant();
    
    // 直接从结果集中读取数据
    QVariant val = d->dataValue(field);
    
    return val;
}

/**
 * @brief 检查指定字段是否为空值
 * @param field 字段索引
 * @return 如果为空值返回true，否则返回false
 */
bool QDuckdbResult::isNull(int field)
{
    Q_D(QDuckdbResult);
    if (field < 0 || field >= record().count())
        return true;
    return d->isValueNull(field);
}

/**
 * @brief 获取结果集的行数
 * @return 结果集行数
 */
int QDuckdbResult::size()
{
    Q_D(QDuckdbResult);
    return d->rowCount;
}

/**
 * @brief 获取受影响的行数
 * @return 受影响的行数
 */
int QDuckdbResult::numRowsAffected()
{
    Q_D(QDuckdbResult);
    return d->affectedRows;
}

/**
 * @brief 获取查询结果的记录结构
 * @return 记录结构信息
 */
QSqlRecord QDuckdbResult::record() const
{
    Q_D(const QDuckdbResult);
    return d->record;
}

/**
 * @brief 从结果集中分离
 */
void QDuckdbResult::detachFromResultSet()
{
    Q_D(QDuckdbResult);
    d->cleanup();
}

/**
 * @brief 切换到下一个结果集
 * @return DuckDB不支持多结果集，始终返回false
 */
bool QDuckdbResult::nextResult()
{
    // DuckDB doesn't support multiple result sets in a single query
    return false;
}

/**
 * @brief 虚拟钩子函数
 * @param id 钩子ID
 * @param data 钩子数据
 */
void QDuckdbResult::virtual_hook(int id, void *data)
{
    Q_UNUSED(id);
    Q_UNUSED(data);
    // 不实现virtual_hook方法，避免调用父类不存在的方法
}

/**
 * @brief 执行批量操作
 * @param arrayBind 是否使用数组绑定模式
 * @return 成功返回true，失败返回false
 */
bool QDuckdbResult::execBatch(bool arrayBind)
{
    Q_D(QDuckdbResult);
    
    if (!d->stmt) {
        setLastError(QSqlError(QStringLiteral("Statement not prepared"), 
                              QString(), QSqlError::StatementError));
        return false;
    }

    // 获取绑定值
    QVariantList values = boundValues();
    if (values.isEmpty()) {
        setLastError(QSqlError(QStringLiteral("No values to bind"), 
                              QString(), QSqlError::StatementError));
        return false;
    }

    // 检查绑定值是否为QVariantList类型，如果是，则自动切换到数组绑定模式
    bool useArrayBind = arrayBind;
    if (!useArrayBind) {
        // 检查是否所有绑定值都是QVariantList类型
        bool allLists = true;
        for (const QVariant &v : values) {
            if (v.metaType().id() != QMetaType::QVariantList) {
                allLists = false;
                break;
            }
        }
        
        // 如果所有绑定值都是QVariantList类型，自动切换到数组绑定模式
        if (allLists) {
            useArrayBind = true;
        }
    }

    // 检查是否为数组绑定
    if (useArrayBind) {
        // 数组绑定模式 - 每个绑定值应该是一个QVariantList
        QVector<QVariantList> batches;
        for (int i = 0; i < values.size(); ++i) {
            const QVariant &v = values[i];
            // 检查是否为QVariantList类型
            if (v.metaType().id() != QMetaType::QVariantList) {
                setLastError(QSqlError(QStringLiteral("Invalid batch bind values"), 
                                      QString(), QSqlError::StatementError));
                return false;
            }
            
            QVariantList list = v.toList();
            batches.append(list);
        }

        // 检查批次大小
        if (batches.isEmpty()) {
            setLastError(QSqlError(QStringLiteral("No batch data"), 
                                  QString(), QSqlError::StatementError));
            return false;
        }

        int batchSize = batches.first().size();
        if (batchSize == 0) {
            setLastError(QSqlError(QStringLiteral("Batch size is zero"), 
                                  QString(), QSqlError::StatementError));
            return false;
        }

        // 检查所有批次大小是否一致
        for (int i = 0; i < batches.size(); ++i) {
            if (batches[i].size() != batchSize) {
                setLastError(QSqlError(QStringLiteral("Inconsistent batch sizes"), 
                                      QString(), QSqlError::StatementError));
                return false;
            }
        }

        // 执行批量插入
        int successCount = 0;
        for (int i = 0; i < batchSize; ++i) {
            // 重置语句状态，确保每次执行都是干净的
            duckdb_destroy_result(&d->result);
            
            // 绑定当前行的值
            for (int j = 0; j < batches.size(); ++j) {
                if (!d->bindValue(j, batches[j][i])) {
                    setLastError(QSqlError(QStringLiteral("Binding error"), 
                                          d->lastError(), QSqlError::StatementError));
                    return false;
                }
            }
            
            // 执行当前行
            if (!d->execute()) {
                setLastError(QSqlError(QStringLiteral("Execution error"), 
                                      d->lastError(), QSqlError::StatementError));
                return false;
            }
            successCount++;
        }
    } else {
        // 非数组绑定模式 - 直接执行多次
        int successCount = 0;
        for (int i = 0; i < values.size(); ++i) {
            const QVariant &v = values[i];
            
            // 重置语句状态，确保每次执行都是干净的
            duckdb_destroy_result(&d->result);
            
            if (!d->bindValue(i, v)) {  // 修改这里，使用索引i而不是固定的0
                setLastError(QSqlError(QStringLiteral("Binding error"), 
                                      d->lastError(), QSqlError::StatementError));
                return false;
            }
            
            // 如果这是最后一个参数，执行查询
            if (i == values.size() - 1) {
                if (!d->execute()) {
                    setLastError(QSqlError(QStringLiteral("Execution error"), 
                                          d->lastError(), QSqlError::StatementError));
                    return false;
                }
                successCount++;
            }
        }
        
    }

    // 处理结果
    bool isSelect = (duckdb_column_count(&d->result) > 0);
    setSelect(isSelect);
    setActive(true);  // 设置为活动状态，表示操作成功
    setAt(isSelect ? QSql::BeforeFirstRow : QSql::AfterLastRow);
    
    if (isSelect) {
        d->rowCount = duckdb_row_count(&d->result);
        d->affectedRows = 0;
    } else {
        d->affectedRows = duckdb_rows_changed(&d->result);
        if (d->affectedRows < 0) {
            d->affectedRows = 0;
        }
    }
    return true;
}


QT_END_NAMESPACE

#include "moc_qsql_duckdb.cpp"